/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.brain.core.manager;

import com.brain.conf.dto.MonedaDto;
import com.brain.conf.manager.MonedaManager;
import com.brain.core.common.UtilCore;
import com.brain.core.configuracion.WebServletContextListener;
import com.brain.core.dto.EmpresaDto;
import com.brain.core.dto.OrganizacionDto;

import com.brain.core.exception.DAOException;
import com.brain.core.hibernate.dao.DAOGenerico;
import com.brain.core.view.mbean.ApplicationMBean;
import com.brain.core.view.mbean.ArchivoMBean;
import com.brain.core.view.mbean.PropietarioMBean;
import com.brain.core.view.mbean.SessionMBean;
import com.brain.segu.dto.UsuarioDto;
import com.brain.segu.manager.UsuarioManager;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Serializable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Service;

/**
 *
 * @author Indra
 */
@Service
public class OrganizacionManager extends ComunManager<OrganizacionDto> implements Serializable {

    private static Logger logger = Logger.getLogger(OrganizacionManager.class);
    private Long idEntidad = 151L;
    private final Long organizacionTodos = 5L;
    @Resource
    private DAOGenerico<OrganizacionDto> springHibernateDao;
    @Resource
    private RecursosManager recursosManager;
    @Resource
    private EmpresaManager empresaManager;
    private final String url = "/pages/core/organizacion/organizacion.xhtml";
    private final String urlLista = "/pages/core/organizacion/listaOrganizaciones.xhtml";
    private Long idOrganizacionSystem = 101L;
    private EmpresaDto empresaSystem;

    /**
     * Metodo para obtener todas las organizaciones
     *
     * @return lista de organizaciones
     * @throws DAOException
     */
    public List<OrganizacionDto> obtenerTodos() throws DAOException {
        return springHibernateDao.listarTodosDtos(OrganizacionDto.class);
    }

    /**
     * Metodo para obtener una organizacion por su ID
     *
     * @param id ID de la empresa
     * @return Organizacion
     * @throws DAOException
     */
    public OrganizacionDto obtenerPorId(Long id) throws DAOException {
        return springHibernateDao.obtenerDtoPorId(OrganizacionDto.class, id);
    }

    /**
     * Metodo para obtener organizaciones por un mapa de filtros
     *
     * @param filtros mapa de filtros
     * @return lista de empresas
     * @throws DAOException
     */
    public List<OrganizacionDto> obtenerConFiltro(Map<String, Object> filtros) throws DAOException {
        return springHibernateDao.obtenerDtosConFiltros(OrganizacionDto.class, filtros);
    }

    /**
     * Metodo para obtener organizaciones por un mapa de filtros y un mapa de
     * orden
     *
     * @param filtros mapa de filtros
     * @param orden mapa de orden
     * @return lista de organizaciones
     * @throws DAOException
     */
    public List<OrganizacionDto> obtenerConFiltroConOrden(Map<String, Object> filtros, Map<String, String> orden) throws DAOException {
        return springHibernateDao.obtenerDtosConFiltrosConOrden(OrganizacionDto.class, filtros, orden);
    }

    /**
     * Metodo para obtener organizaciones de acuerdo a un filtro
     *
     * @param dtoFiltro filtros
     * @return lista de organizaciones
     * @throws DAOException
     */
    public List<OrganizacionDto> obtenerOrganizacionesPorEmpresaSession() throws DAOException {
        SessionMBean sessionMBean = (SessionMBean) WebServletContextListener.getApplicationContext().getBean("sessionMBean");
        List<OrganizacionDto> lista = null;
        Map<String, Object> mapFiltro = new HashMap<String, Object>();
        mapFiltro.put("empresa", sessionMBean.getEmpresaDto().getId());
        mapFiltro.put("estado", Boolean.TRUE);

        Map<String, String> mapOrden = new HashMap<String, String>();
        mapOrden.put("nombre", "asc");
        lista = obtenerConFiltroConOrden(mapFiltro, mapOrden);

        return lista;

    }

    /**
     * Metodo para obtener filtros de acuerdo a un filtro
     *
     * @param dtoFiltro filtros
     * @return lista de organizaciones
     * @throws DAOException
     */
    public List<OrganizacionDto> obtener(OrganizacionDto dtoFiltro) throws DAOException {
        List<OrganizacionDto> lista = null;
        Map<String, Object> mapFiltro = new HashMap<String, Object>();
        if (dtoFiltro.getId() != null && !dtoFiltro.getId().equals(0L)) {
            mapFiltro.put("id", dtoFiltro.getId());
        } else {
            dtoFiltro.setId(null);
        }
        if (dtoFiltro.getNombre() != null && dtoFiltro.getNombre().length() != 0) {
            mapFiltro.put("nombre", dtoFiltro.getDescripcion());
        }

        if (dtoFiltro.getEstado() != null) {
            mapFiltro.put("estado", dtoFiltro.getEstado());
        }

        mapFiltro.put("empresaDto.id", dtoFiltro.getEmpresaDto().getId());

        Map<String, String> mapOrden = new HashMap<String, String>();
        mapOrden.put("nombre", "asc");

        lista = obtenerConFiltroConOrden(mapFiltro, mapOrden);

        return lista;

    }

    /**
     * Retorna todos las organizaciones activos ordenados por descripcion
     * adicionando la organizacion todos
     *
     * @return Lista de Organizaciones
     * @throws DAOException
     */
    public List<OrganizacionDto> obtenerTodosActivosTodos() throws DAOException {
        OrganizacionDto dtoFiltro = new OrganizacionDto();
        dtoFiltro.setEstado(Boolean.TRUE);
        List<OrganizacionDto> l = obtener(dtoFiltro);

        OrganizacionDto r = obtenerPorId(organizacionTodos);
        if (r != null) {
            l.add(r);
        }

        return l;
    }

    /**
     * Metodo que obtiene organizaciones activas
     *
     * @return lista de organizaciones
     * @throws DAOException
     */
    public List<OrganizacionDto> obtenerActivos() throws DAOException {
        Map<String, Object> filtros = new HashMap<String, Object>();
        filtros.put("estado", Boolean.TRUE);
        Map<String, String> orden = new HashMap<String, String>();
        orden.put("nombre", "asc");
        return springHibernateDao.obtenerDtosConFiltrosConOrden(OrganizacionDto.class, filtros, orden);
    }

    public List<OrganizacionDto> obtenerActivosPorEmpresa(EmpresaDto empDto) throws DAOException {
        Map<String, Object> filtros = new HashMap<String, Object>();
        filtros.put("estado", Boolean.TRUE);
        filtros.put("empresaDto.id", empDto.getId());
        Map<String, String> orden = new HashMap<String, String>();
        orden.put("nombre", "asc");
        return springHibernateDao.obtenerDtosConFiltrosConOrden(OrganizacionDto.class, filtros, orden);
    }

    /**
     * Metodo para inicializar los atributos de una organizacion
     *
     * @return Organizacion
     */
    public OrganizacionDto inicializar() {
        OrganizacionDto dto = new OrganizacionDto();
        try {
            ApplicationMBean applicationMBean = (ApplicationMBean) WebServletContextListener.getApplicationContext().getBean("applicationMBean");
            SessionMBean sessionMBean = (SessionMBean) WebServletContextListener.getApplicationContext().getBean("sessionMBean");

            ///Obtenemos la empresa de la sesion del usuario conectado
            if (sessionMBean.getEmpresaDto() != null) {
                if (sessionMBean.getEmpresaDto().getId() != null) {
                    dto.setEmpresaDto(this.empresaManager.obtenerPorId(sessionMBean.getEmpresaDto().getId()));
                }
            }
            dto.setEstado(Boolean.TRUE);
            dto.setPaisDto(applicationMBean.getDefaultPaisDto());
            dto.setMonedaDto(null);
            dto.setAddItemsPC(Boolean.FALSE);
            dto.setTcCompra(Boolean.FALSE);
            dto.setTcVenta(Boolean.FALSE);
            dto.setNumPC(Boolean.TRUE);
        } catch (Exception ex) {
            recursosManager.showError(ex.getMessage());
            logger.error(ex.getMessage());
        }
        return dto;
    }

    public MonedaDto obtenerMonedaDelPaisDelaOrg(OrganizacionDto dto) {
        try {
            MonedaManager monedaManager = (MonedaManager) WebServletContextListener.getApplicationContext().getBean("monedaManager");
            List<MonedaDto> lstMonedaDto = monedaManager.obtenerMonedaPorPais(dto.getPaisDto());
            if (!lstMonedaDto.isEmpty()) {
                return lstMonedaDto.get(0);
            }
        } catch (DAOException ex) {
            logger.error(ex.getMessage());
        }
        return null;
    }

    /**
     * Metodo para guardar los datos de una organizacion
     *
     * @param dto Organizacion a guardar
     * @return Cadena de satisfaccion
     */
    public String guardar(OrganizacionDto dto) {

        String to = null;
        String mensajeTrx = "";
        SessionMBean sessionMBean = (SessionMBean) WebServletContextListener.getApplicationContext().getBean("sessionMBean");
        ApplicationMBean applicationMBean = (ApplicationMBean) WebServletContextListener.getApplicationContext().getBean("applicationMBean");

        {
            dto.setUsuarioDto(sessionMBean.getSessionUsuarioDto());
            dto.setFecha(UtilCore.Fecha.obtenerFechaActualDate());
            dto.setTerminal(sessionMBean.getSessionTerminal());
        }

        if (sessionMBean.getAccion() == applicationMBean.getNuevo()) {
            try {
                dto.setUsuarioCreacionDto(sessionMBean.getSessionUsuarioDto());
                dto.setFechaCreacion(UtilCore.Fecha.obtenerFechaActualDate());
                dto.setTerminalCreacion(sessionMBean.getSessionTerminal());
                UtilCore.General.toUpperCaseDto(dto);
                nuevo(dto);
                //Agregamos como propietario de esta nueva organizacion al usuario system de la empresa en sesion
                generarPropietarioParaUsuarioSystem(dto);
                mensajeTrx = UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok");
                recursosManager.showMessage(mensajeTrx);

                to = "";//retroceder();
            } catch (Exception ex) {
                mensajeTrx = ex.getMessage();
                recursosManager.showError(ex.getMessage());
                logger.error(mensajeTrx);

                to = null;
            }
        } else if (sessionMBean.getAccion() == applicationMBean.getEditar()) {
            /*Guardamos el archivo de lo logo*/

            {
                ArchivoMBean archivoMBean = (ArchivoMBean) WebServletContextListener.getApplicationContext().getBean("archivoMBean");

                try {
                    if (dto.getArchivoLogoDto() != null && getIdEntidad() != null) {
                        archivoMBean.grabarArchivo(dto.getArchivoLogoDto(), getIdEntidad(), dto.getId());
                    }
                } catch (FileNotFoundException ex) {
                    recursosManager.showError("ARCHIVO NO ENCONTRADO :: " + ex.getMessage());
                    logger.error(ex);
                } catch (IOException ex) {
                    recursosManager.showError("ERROR DE ENTRADA Y SALIDA :: " + ex.getMessage());
                    logger.error(ex);
                }
            }
            try {
                UtilCore.General.toUpperCaseDto(dto);
                editar(dto);
                mensajeTrx = UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok");
                recursosManager.showMessage(mensajeTrx);
                to = "";//retroceder();
            } catch (Exception ex) {
                mensajeTrx = ex.getMessage();
                recursosManager.showError(ex.getMessage());
                logger.error(mensajeTrx);
                to = null;
            }
        }



        return to;
    }

    /**
     *
     * @param dto
     */
    public void generarPropietarioParaUsuarioSystem(OrganizacionDto dto) {
        try {
            SessionMBean sessionMBean = (SessionMBean) WebServletContextListener.getApplicationContext().getBean("sessionMBean");
            UsuarioManager usuarioManager = (UsuarioManager) WebServletContextListener.getApplicationContext().getBean("usuarioManager");
            //Obtenemos el usuario System de la empresa
            UsuarioDto usSystemEmp = usuarioManager.obtenerSystemPorEmpresa(sessionMBean.getEmpresaDto()).get(0);
            sessionMBean.setEntidad(usuarioManager.getIdEntidad());
            sessionMBean.setRegistro(usSystemEmp.getId());
            PropietarioMBean propietarioMBean = (PropietarioMBean) WebServletContextListener.getApplicationContext().getBean("propietarioMBean");
            propietarioMBean.setOrganizacionDto(dto);
            propietarioMBean.setEstado(Boolean.TRUE);
            propietarioMBean.setPrincipal(Boolean.FALSE);
            propietarioMBean.nuevoPropietario();
        } catch (DAOException ex) {
            recursosManager.showError(ex.getMessage());
            logger.error(ex.getMessage());
        }
    }

    public static Logger getLogger() {
        return logger;
    }

    public static void setLogger(Logger logger) {
        OrganizacionManager.logger = logger;
    }

    public DAOGenerico<OrganizacionDto> getSpringHibernateDao() {
        return springHibernateDao;
    }

    public void setSpringHibernateDao(DAOGenerico<OrganizacionDto> springHibernateDao) {
        this.springHibernateDao = springHibernateDao;
    }

    public RecursosManager getRecursosManager() {
        return recursosManager;
    }

    public void setRecursosManager(RecursosManager recursosManager) {
        this.recursosManager = recursosManager;
    }

    public EmpresaManager getEmpresaManager() {
        return empresaManager;
    }

    public void setEmpresaManager(EmpresaManager empresaManager) {
        this.empresaManager = empresaManager;
    }

    public Long getIdOrganizacionSystem() {
        return idOrganizacionSystem;
    }

    public void setIdOrganizacionSystem(Long idOrganizacionSystem) {
        this.idOrganizacionSystem = idOrganizacionSystem;
    }

    public EmpresaDto getEmpresaSystem() {
        return empresaSystem;
    }

    public void setEmpresaSystem(EmpresaDto empresaSystem) {
        this.empresaSystem = empresaSystem;
    }

    public String getUrl() {
        return url;
    }

    public String getUrlLista() {
        return urlLista;
    }

    public Long getIdEntidad() {
        return idEntidad;
    }

    public void setIdEntidad(Long idEntidad) {
        this.idEntidad = idEntidad;
    }

    public Long getOrganizacionTodos() {
        return organizacionTodos;
    }
}
